home *** CD-ROM | disk | FTP | other *** search
/ All for Cell Phones: Sony Ericsson / Sony-Ericsson 2004.iso / Java / Calc / MicroCalc.jar / MathFP.class (.txt) < prev    next >
Encoding:
Java Class File  |  2001-09-07  |  5.7 KB  |  398 lines
  1. public abstract class MathFP {
  2.    private static int _fbits = 24;
  3.    private static int _digits = 8;
  4.    private static long _one = 16777216L;
  5.    private static long _fmask = 16777215L;
  6.    private static long _dmul = 100000000L;
  7.    private static long _flt = 0L;
  8.    private static long _pi = 52707178L;
  9.    // $FF: renamed from: e long[]
  10.    private static long[] field_0;
  11.    // $FF: renamed from: PI long
  12.    public static long field_1;
  13.    // $FF: renamed from: E long
  14.    public static long field_2;
  15.    public static final long MAX_VALUE = Long.MAX_VALUE;
  16.    public static final long MIN_VALUE = -9223372036854775807L;
  17.  
  18.    static {
  19.       field_0 = new long[]{_one, 45605201L, 123967790L, 336979391L, 916004956L};
  20.       field_1 = _pi;
  21.       field_2 = field_0[1];
  22.    }
  23.  
  24.    public static long abs(long var0) {
  25.       return var0 < 0L ? -var0 : var0;
  26.    }
  27.  
  28.    public static long acos(long var0) {
  29.       return field_1 / 2L - asin(var0);
  30.    }
  31.  
  32.    public static long add(long var0, long var2) {
  33.       return var0 + var2;
  34.    }
  35.  
  36.    public static long asin(long var0) {
  37.       if (abs(var0) > _one) {
  38.          throw new ArithmeticException("Bad Input");
  39.       } else {
  40.          boolean var2 = var0 < 0L;
  41.          var0 = abs(var0);
  42.          long var3 = mul(mul(mul(mul((long)(145103 >> (int)_flt), var0) - (long)(599880 >> (int)_flt), var0) + (long)(1420468 >> (int)_flt), var0) - (long)(3592413 >> (int)_flt), var0) + (long)(26353447 >> (int)_flt);
  43.          long var5 = field_1 / 2L - mul(sqrt(_one - var0), var3);
  44.          return var2 ? -var5 : var5;
  45.       }
  46.    }
  47.  
  48.    public static long atan(long var0) {
  49.       return asin(div(var0, sqrt(_one + mul(var0, var0))));
  50.    }
  51.  
  52.    public static long atan2(long var0, long var2) {
  53.       long var4 = 0L;
  54.       if (var2 > 0L) {
  55.          var4 = atan(div(var0, var2));
  56.       } else if (var2 < 0L) {
  57.          var4 = (var2 < 0L ? -field_1 : field_1) - atan(abs(div(var0, var2)));
  58.       } else {
  59.          if (var2 == 0L && var0 == 0L) {
  60.             throw new ArithmeticException("Bad Input");
  61.          }
  62.  
  63.          var4 = (var0 < 0L ? -field_1 : field_1) / 2L;
  64.       }
  65.  
  66.       return var4;
  67.    }
  68.  
  69.    public static long convert(long var0, int var2) {
  70.       long var3 = (long)(var0 < 0L ? -1 : 1);
  71.       if (abs((long)var2) < 25L) {
  72.          if (_fbits < var2) {
  73.             var0 = var0 + var3 * (1L << (var2 - _fbits >> 1)) >> var2 - _fbits;
  74.          } else {
  75.             var0 <<= _fbits - var2;
  76.          }
  77.       }
  78.  
  79.       return var0;
  80.    }
  81.  
  82.    public static long cos(long var0) {
  83.       return sin(field_1 / 2L - var0);
  84.    }
  85.  
  86.    public static long cot(long var0) {
  87.       return div(cos(var0), sin(var0));
  88.    }
  89.  
  90.    public static long div(long var0, long var2) {
  91.       boolean var4 = false;
  92.       int var5 = _fbits;
  93.       if (var2 == _one) {
  94.          return var0;
  95.       } else if ((var2 & _fmask) == 0L) {
  96.          return var0 / (var2 >> var5);
  97.       } else {
  98.          if (var0 < 0L && var2 > 0L || var0 > 0L && var2 < 0L) {
  99.             var4 = true;
  100.          }
  101.  
  102.          if (var0 < 0L) {
  103.             var0 = -var0;
  104.          }
  105.  
  106.          if (var2 < 0L) {
  107.             var2 = -var2;
  108.          }
  109.  
  110.          while(max(var0, var2) >= 1L << 63 - var5) {
  111.             var0 >>= 1;
  112.             var2 >>= 1;
  113.             --var5;
  114.          }
  115.  
  116.          long var6 = (var0 << var5) / var2 << _fbits - var5;
  117.          return var4 ? -var6 : var6;
  118.       }
  119.    }
  120.  
  121.    public static long exp(long var0) {
  122.       if (var0 == 0L) {
  123.          return _one;
  124.       } else {
  125.          boolean var2 = var0 < 0L;
  126.          var0 = abs(var0);
  127.          int var3 = (int)(var0 >> _fbits);
  128.          long var4 = _one;
  129.  
  130.          for(int var6 = 0; var6 < var3 / 4; ++var6) {
  131.             var4 = mul(var4, field_0[4] >> (int)_flt);
  132.          }
  133.  
  134.          if (var3 % 4 > 0) {
  135.             var4 = mul(var4, field_0[var3 % 4] >> (int)_flt);
  136.          }
  137.  
  138.          var0 &= _fmask;
  139.          if (var0 > 0L) {
  140.             long var7 = _one;
  141.             long var9 = 0L;
  142.             long var11 = 1L;
  143.  
  144.             for(int var13 = 0; var13 < 16; ++var13) {
  145.                var9 += var7 / var11;
  146.                var7 = mul(var7, var0);
  147.                var11 *= (long)(var13 + 1);
  148.                if (var11 > var7 || var7 <= 0L || var11 <= 0L) {
  149.                   break;
  150.                }
  151.             }
  152.  
  153.             var4 = mul(var4, var9);
  154.          }
  155.  
  156.          if (var2) {
  157.             var4 = div(_one, var4);
  158.          }
  159.  
  160.          return var4;
  161.       }
  162.    }
  163.  
  164.    public static int getPrecision() {
  165.       return _fbits;
  166.    }
  167.  
  168.    public static long log(long var0) {
  169.       // $FF: Couldn't be decompiled
  170.    }
  171.  
  172.    public static long max(long var0, long var2) {
  173.       return var0 < var2 ? var2 : var0;
  174.    }
  175.  
  176.    public static long min(long var0, long var2) {
  177.       return var2 < var0 ? var2 : var0;
  178.    }
  179.  
  180.    public static long mul(long var0, long var2) {
  181.       boolean var4 = false;
  182.       int var5 = _fbits;
  183.       long var6 = _fmask;
  184.       if ((var0 & var6) == 0L) {
  185.          return (var0 >> var5) * var2;
  186.       } else if ((var2 & var6) == 0L) {
  187.          return var0 * (var2 >> var5);
  188.       } else {
  189.          if (var0 < 0L && var2 > 0L || var0 > 0L && var2 < 0L) {
  190.             var4 = true;
  191.          }
  192.  
  193.          if (var0 < 0L) {
  194.             var0 = -var0;
  195.          }
  196.  
  197.          if (var2 < 0L) {
  198.             var2 = -var2;
  199.          }
  200.  
  201.          while(max(var0, var2) >= 1L << 63 - var5) {
  202.             var0 >>= 1;
  203.             var2 >>= 1;
  204.             var6 >>= 1;
  205.             --var5;
  206.          }
  207.  
  208.          long var8 = (var0 >> var5) * (var2 >> var5) << var5;
  209.          long var10 = (var0 & var6) * (var2 & var6) >> var5;
  210.          var10 += (var0 & ~var6) * (var2 & var6) >> var5;
  211.          var8 = var8 + var10 + ((var0 & var6) * (var2 & ~var6) >> var5) << _fbits - var5;
  212.          if (var8 < 0L) {
  213.             throw new ArithmeticException("Overflow");
  214.          } else {
  215.             return var4 ? -var8 : var8;
  216.          }
  217.       }
  218.    }
  219.  
  220.    public static long pow(long var0, long var2) {
  221.       boolean var4 = var2 < 0L;
  222.       long var5 = _one;
  223.       var2 = abs(var2);
  224.  
  225.       for(int var7 = (int)var2 >> _fbits; var7-- > 0; var5 = mul(var5, var0)) {
  226.       }
  227.  
  228.       if (var5 < 0L) {
  229.          throw new ArithmeticException("Overflow");
  230.       } else {
  231.          if (var0 != 0L) {
  232.             var5 = mul(var5, exp(mul(log(var0), var2 & _fmask)));
  233.          } else {
  234.             var5 = 0L;
  235.          }
  236.  
  237.          return var4 ? div(_one, var5) : var5;
  238.       }
  239.    }
  240.  
  241.    public static long round(long var0, int var2) {
  242.       long var3 = 10L;
  243.  
  244.       for(int var5 = 0; var5 < var2; ++var5) {
  245.          var3 *= 10L;
  246.       }
  247.  
  248.       var3 = div(toFP(5L), toFP(var3));
  249.       if (var0 < 0L) {
  250.          var3 = -var3;
  251.       }
  252.  
  253.       return var0 + var3;
  254.    }
  255.  
  256.    public static int setPrecision(int var0) {
  257.       if (var0 <= 24 && var0 >= 0) {
  258.          _fbits = var0;
  259.          _one = 1L << var0;
  260.          _flt = (long)(24 - var0);
  261.          _digits = 0;
  262.          _dmul = 1L;
  263.          _fmask = _one - 1L;
  264.          field_1 = _pi >> (int)_flt;
  265.          field_2 = field_0[1] >> (int)_flt;
  266.  
  267.          for(long var1 = _one; var1 != 0L; _dmul *= 10L) {
  268.             var1 /= 10L;
  269.             ++_digits;
  270.          }
  271.  
  272.          return _digits;
  273.       } else {
  274.          return _digits;
  275.       }
  276.    }
  277.  
  278.    public static long sin(long var0) {
  279.       long var2 = mul(var0, div(toFP(180L), field_1));
  280.       var2 %= toFP(360L);
  281.       if (var2 < 0L) {
  282.          var2 += toFP(360L);
  283.       }
  284.  
  285.       long var4 = var2;
  286.       if (var2 >= toFP(90L) && var2 < toFP(270L)) {
  287.          var4 = toFP(180L) - var2;
  288.       } else if (var2 >= toFP(270L) && var2 < toFP(360L)) {
  289.          var4 = -(toFP(360L) - var2);
  290.       }
  291.  
  292.       long var6 = var4 / 90L;
  293.       long var8 = mul(var6, var6);
  294.       long var10 = mul(mul(mul(mul(-73190L >> (int)_flt, var8) + (1333581L >> (int)_flt), var8) - (10836755L >> (int)_flt), var8) + (long)(26353564 >> (int)_flt), var6);
  295.       return var10;
  296.    }
  297.  
  298.    public static long sqrt(long var0) {
  299.       return sqrt(var0, 24);
  300.    }
  301.  
  302.    public static long sqrt(long var0, int var2) {
  303.       if (var0 < 0L) {
  304.          throw new ArithmeticException("Bad Input");
  305.       } else if (var0 == 0L) {
  306.          return 0L;
  307.       } else {
  308.          long var3 = var0 + _one >> 1;
  309.  
  310.          for(int var5 = 0; var5 < var2; ++var5) {
  311.             var3 = var3 + div(var0, var3) >> 1;
  312.          }
  313.  
  314.          if (var3 < 0L) {
  315.             throw new ArithmeticException("Overflow");
  316.          } else {
  317.             return var3;
  318.          }
  319.       }
  320.    }
  321.  
  322.    public static long sub(long var0, long var2) {
  323.       return var0 - var2;
  324.    }
  325.  
  326.    public static long tan(long var0) {
  327.       return div(sin(var0), cos(var0));
  328.    }
  329.  
  330.    public static long toFP(long var0) {
  331.       return var0 << _fbits;
  332.    }
  333.  
  334.    public static long toFP(String var0) {
  335.       byte var1 = 0;
  336.       if (var0.charAt(0) == '-') {
  337.          var1 = 1;
  338.       }
  339.  
  340.       String var2 = "-1";
  341.       int var3 = var0.indexOf(46);
  342.       if (var3 >= 0) {
  343.          for(var2 = var0.substring(var3 + 1, var0.length()); var2.length() < _digits; var2 = var2 + "0") {
  344.          }
  345.  
  346.          if (var2.length() > _digits) {
  347.             var2 = var2.substring(0, _digits);
  348.          }
  349.       } else {
  350.          var3 = var0.length();
  351.       }
  352.  
  353.       long var4 = 0L;
  354.       if (var1 != var3) {
  355.          var4 = Long.parseLong(var0.substring(var1, var3));
  356.       }
  357.  
  358.       long var6 = Long.parseLong(var2) + 1L;
  359.       long var8 = (var4 << _fbits) + (var6 << _fbits) / _dmul;
  360.       if (var1 == 1) {
  361.          var8 = -var8;
  362.       }
  363.  
  364.       return var8;
  365.    }
  366.  
  367.    public static long toLong(long var0) {
  368.       var0 = round(var0, 0);
  369.       return var0 >> _fbits;
  370.    }
  371.  
  372.    public static String toString(long var0) {
  373.       boolean var2 = false;
  374.       if (var0 < 0L) {
  375.          var2 = true;
  376.          var0 = -var0;
  377.       }
  378.  
  379.       long var3 = var0 >> _fbits;
  380.       long var5 = _dmul * (var0 & _fmask) >> _fbits;
  381.  
  382.       String var7;
  383.       for(var7 = Long.toString(var5); var7.length() < _digits; var7 = "0" + var7) {
  384.       }
  385.  
  386.       return (var2 ? "-" : "") + Long.toString(var3) + "." + var7;
  387.    }
  388.  
  389.    public static String toString(long var0, int var2) {
  390.       if (var2 > _digits) {
  391.          var2 = _digits;
  392.       }
  393.  
  394.       String var3 = toString(round(var0, var2));
  395.       return var3.substring(0, var3.length() - _digits + var2);
  396.    }
  397. }
  398.